#include <vrmllib/nodes.h>

#include <map>
#include <stdexcept>

#include <vrmllib/types_bits.h>

#define BEGIN_NODE(type) \
	namespace {\
	node_creator<type> register_##type##_creator(#type); \
	} \
	void type::parse_attribute(const std::string &a_name, \
		std::istream &a_stream, file &a_data) \
	{

#define ATTR(d_var) \
		if (a_name == #d_var) { \
			using namespace bits; \
			return parse_value(d_var, a_stream, a_data); \
		} 
#define VATTR(d_var) \
		if (a_name == #d_var) { \
			using namespace bits; \
			return parse_vector(d_var, a_stream, a_data); \
		} 
#define END_NODE \
		base_type::parse_attribute(a_name, a_stream, a_data); \
	}

#define BEGIN_DEFAULTS(type) \
	type::type() :
#define END_DEFAULTS \
	{}

namespace vrmllib {
namespace bits {

class node_creator_base {
public:
	virtual ~node_creator_base() {}
	virtual node *create() = 0;
};

std::map<std::string, node_creator_base *> g_node_creators;

template<class Type>
class node_creator : public node_creator_base {
public:
	node_creator(const char *type) { g_node_creators[type] = this; }
	node *create() { return new Type; }
};

} // namespace bits

using namespace bits;

node *node::create_node(const std::string &type)
{
	node_creator_base *c = g_node_creators[type];

	if (c)
		return c->create();
	else {
		std::cerr << "unknown type: " << type << std::endl;
		return 0;
	}
}

BEGIN_NODE(grouping_node)
	VATTR(children)
END_NODE

BEGIN_DEFAULTS(Transform)
	translation(0,0,0),
	center(0,0,0),
	scale(1,1,1)
END_DEFAULTS
BEGIN_NODE(Transform)
	ATTR(translation)
	ATTR(rotation)
	ATTR(center)
	ATTR(scale)
	ATTR(scaleOrientation)
END_NODE

BEGIN_NODE(Group)
END_NODE

BEGIN_DEFAULTS(Shape)
	appearance(0),
	geometry(0)
END_DEFAULTS
BEGIN_NODE(Shape)
	ATTR(appearance)
	ATTR(geometry)
END_NODE

BEGIN_DEFAULTS(Switch)
	whichChoice(0)
END_DEFAULTS
BEGIN_NODE(Switch)
	VATTR(choice)
	ATTR(whichChoice)
END_NODE

BEGIN_DEFAULTS(Viewpoint)
	fieldOfView(0.785398),
	position(0,0,10)
END_DEFAULTS
BEGIN_NODE(Viewpoint)
	ATTR(fieldOfView)
	ATTR(orientation)
	ATTR(position)
	ATTR(description)
END_NODE

BEGIN_DEFAULTS(Appearance)
	material(0),
	texture(0)
END_DEFAULTS
BEGIN_NODE(Appearance)
	ATTR(material)
	ATTR(texture)
END_NODE

BEGIN_NODE(WorldInfo)
	ATTR(title)
	VATTR(info)
END_NODE

BEGIN_DEFAULTS(Material)
	diffuseColor(204,204,204),
	specularColor(0,0,0),
	emissiveColor(0,0,0),
	ambientIntensity(0.2),
	shininess(0.2),
	transparency(0)
END_DEFAULTS
BEGIN_NODE(Material)
	ATTR(diffuseColor)
	ATTR(specularColor)
	ATTR(emissiveColor)
	ATTR(ambientIntensity)
	ATTR(shininess)
	ATTR(transparency)
END_NODE

BEGIN_DEFAULTS(IndexedFaceSet)
	solid(true),
	convex(true),
	ccw(true),
	normalPerVertex(true),
	colorPerVertex(true),
	coord(0),
	normal(0),
	texCoord(0),
	color(0)
END_DEFAULTS
BEGIN_NODE(IndexedFaceSet)
	ATTR(solid)
	ATTR(convex)
	ATTR(ccw)
	ATTR(normalPerVertex)
	ATTR(colorPerVertex)
	ATTR(coord)
	ATTR(color)
	ATTR(normal)
	ATTR(texCoord)
	VATTR(coordIndex)
	VATTR(texCoordIndex)
	VATTR(normalIndex)
	VATTR(colorIndex)
END_NODE

BEGIN_NODE(Coordinate)
	VATTR(point)
END_NODE

BEGIN_NODE(Color)
	VATTR(color)
END_NODE

BEGIN_NODE(Box)
	ATTR(size)
END_NODE

BEGIN_NODE(Sphere)
	ATTR(radius)
END_NODE

BEGIN_NODE(TextureCoordinate)
	VATTR(point)
END_NODE

BEGIN_NODE(Normal)
	VATTR(vector)
END_NODE

BEGIN_DEFAULTS(ImageTexture)
	repeatS(true), repeatT(true)
END_DEFAULTS
BEGIN_NODE(ImageTexture)
	VATTR(url)
	ATTR(repeatS)
	ATTR(repeatT)
END_NODE

} // namespace vrmllib
